השאלות ידי מצביעים לילדים.

Transcript

1 מבני נתונים פתרונות לסט שאלות דומה לשאלות מתרגיל 4 השאלות 1. כתבו פונקציה לא רקורסיבית שמדפיסה ב- Postorder את כל הנתונים המאוכסנים בעץ בינארי T. הפונקציה אינה צריכה להיות תלויה במימוש העץ T. הניחו שנתון אובייקט מסוג Tree ופעולות בסיסיות המוגדרות עליו, כגון: T. בעץ n פעולה המחזירה את הילד השמאלי של קדקוד - LeftChild(Node (n T. בעץ n פעולה שמחזירה את הנתונים המאוכסנים בקדקוד - Retrieve(Node (n T. פעולה המחזירה את הקדקוד שהוא שורש העץ - Root() T. בעץ n פעולה המחזירה את הקדקוד שהוא אחיו הימני של - RightSibling(Node (n T. בעץ n פעולה המחזירה את הקודקוד שהוא ההורה של Parent(Node (n וכך הלאה. אין צורך לכתוב את הפעולות האלה, ואתם יכולים להגדיר פעולות נוספות סבירות להן אתם זקוקים, ולהשתמש בהן בפונקציה שלכם. רמז: השתמשו במחסנית כמבנה נתונים נוסף. השימוש במחסנית יהיה כקופסה שחורה. 2. נתון עץ בינארי T שבקדקודים שלו יש מספרים טבעיים, חלקם זוגיים, וחלקם אי-זוגיים. העץ ממומש על ידי מצביעים לילדים. כתבו אלגוריתם (T LongestEvenPath(Tree שיחזיר את אורכו של המסלול הארוך ביותר שמתחיל בשורש ומורכב רק מנתונים זוגיים (המסלול אינו חייב להסתיים בעלה). דוגמה: בעץ הבא מודגש המסלול הארוך ביותר (שמתחיל בשורש ומכיל רק זוגיים), האלגוריתם יחזיר, אם כן, את אורכו לשם כתיבת האלגוריתם השתמשו בשני תורים,Q1. Q2 לכל תור מוגדרות הפעולות הבסיסיות הבאות: ) ( MakeEmpty לרוקן את התור. ) ( IsEmpty מחזירה 1 אם התור ריק, 0 אחרת.

2 data) EnQueue (TreeNode מכניסה את הנתון data לתור. הנתון data יכול להיות צומת בעץ, או מצביע לצומת בעץ, עפ"י בחירתכם. ) ( DeQueue מוציאה ומחזירה את הנתון שבראש התור. בנוסף אתם יכולים להשתמש רק בזיכרון נוסף בגודל קבוע (אין להשתמש ברקורסיה). שימו לב, האלגוריתם שלכם ישתמש ב- Q1,Q2 ובפעולות המוגדרות עליהם כבקופסאות שחורות! 3. עץ חיפוש בינארי מחויט (Threaded) הוא עץ חיפוש שבו בכל קדקוד שומרים פרט לנתון ולשני מצביעים לילדים, עוד שני ביטים IsLeft, IsRight שמציינים האם לקדקוד הזה יש ילד שמאל או ילד ימין בהתאמה. אם = 0 IsLeft בקדקוד מסוים, פירוש הדבר שאין לו ילד שמאלי, ואז נשמור במצביע left של אותו קדקוד מצביע לקדקוד שיופיע לפניו במעבר Inorder על העץ (במקום.(NULL אם בקדקוד מסוים = 0,IsRight פירוש הדבר שלקדקוד אין ילד ימני, ואז נשמור במצביע right של אותו קדקוד מצביע אל הקדקוד שיופיע אחריו במעבר.Inorder א. הגדירו ב- ++C מחלקה עבור קדקוד מתאים ומחלקה עבור עץ חיפוש מחויט הבנוי מקדקודים כאלה. ב. כתבו ב- ++C את פעולת Insert עבור עץ חיפוש מחויט וכל פעולה אחרת שבה אתם משתמשים בפונקציה.Insert תארו גם את האלגוריתם שבו אתם משתמשים ונתחו את זמן הריצה של הפונקציה שכתבתם. ג. כתבו ב-++ C פונקציה לא רקורסיבית שעוברת על עץ כזה ב-.Inorder מה זמן הריצה של הפונקציה? א. הוכיחו שבעץ בינארי (לאו דווקא שלם) מספר העלים גדול באחד ממספר הקדקודים מדרגה 2. ב. הוכיחו שבעץ בינארי שלם מגובה h יש 1+h 1 2 קדקודים. (גובה העץ - מספר צלעות מכסימלי לאורך מסלול משורש לעלה כלשהו). ג. מה מספר העלים בעץ בינארי שלם בעל n קדקודים כפונקציה של n? הוכיחו תשובתכם!.4 5. תארו אלגוריתם המקבל מצביע לקדקוד x בעץ חיפוש בינארי ומחזיר מצביע לקדקוד העוקב Successor של x בסדר הממוין הנקבע על-ידי סריקת Inorder של העץ. (ניתן להניח שכל הנתונים שונים, ואז העוקב של הקדקוד x הוא הקדקוד בעל המפתח הקטן ביותר הגדול מהמפתח של הקדקוד ). x האלגוריתם יחזיר NULL אם x הוא הקדקוד בעל המפתח המקסימלי בעץ (ולכן אין לו עוקב). מה יעילות האלגוריתם שמצאתם? הערה: הניחו שהעץ ממומש ע"י מצביעים דו-כוונים (גם לילדים וגם להורה).6 נתונים 3 עצים בינאריים, 3 T 1,T 2,T וידוע שכל אחד מהם מכיל את n המספרים.{1,2, n עוברים על T 1 ב-,Inorder על T 2 ב- Preorder ועל T 3 ב-.Postorder התוצאה המתקבלת בשלושת המעברים האלה היא n,1,2, כלומר המספרים מודפסים בסדר עולה. הוכיחו או הפריכו את הטענות הבאות: א. T 1 הוא בהכרח עץ חיפוש בינארי. ב. T 2 הוא בהכרח עץ חיפוש בינארי. ג. אם נעבור על T 2 ב- Postorder ועל T 3 ב- Preorder נקבל אותו פלט בשני המקרים (לאו דווקא כמובן הפלט n,,1,2).

3 8.7 א. נתון עץ AVL הבא: i) ציירו את העץ המתקבל לאחר הוספת המפתח 15 לעץ. (ii ציירו את העץ המתקבל לאחר הורדת המפתח 3 מהעץ המקורי. ב. נתון עץ בינארי T הכולל n קדקודים, כאשר בקדקודים יש מספרים שלמים השונים זה מזה. העץ T ממומש על ידי מצביעים לילדים. (i) כתבו אלגוריתם יעיל ככל האפשר המחזיר 1 אם העץ T הוא עץ חיפוש בינארי, ומחזיר 0 אחרת. מה יעילותו של האלגוריתם שכתבתם במקרה הגרוע כפונקציה של n? הסבירו תשובתכם. כמו-כן, הוכיחו את נכונות האלגוריתם שכתבם. (ii) כתבו אלגוריתם יעיל ככל האפשר המחזיר 1 אם העץ T הוא עץ,AVL ומחזיר 0 אחרת. מה יעילותו של האלגוריתם שכתבתם במקרה הגרוע? הסבירו תשובתכם. 8. נתון ה- ADT הבא לשמירת נקודות (y,x) במישור הממשי, התומך בפעולות הבאות: (y Insert(x, מכניס את הנקודה (y,x) למבנה ביעילות,O(log(n)) כאשר n הוא מספר הנקודות במבנה. (y Delete(x, מסיר את הנקודה (y,x) מהמבנה ביעילות,O(log(n)) כאשר n הוא מספר הנקודות במבנה. a) SameFactor(double מדפיס את כל הנקודות במבנה המקיימות, x = a y ביעילות log(n)),o(k + כאשר n הוא מספר הנקודות הכולל במבנה, ו- k הוא מספר הנקודות מהמבנה המקיימות קשר זה. הציעו מבנה נתונים למימוש ה- ADT הנ"ל, ופרטו איך תתבצע כל אחת מהפעולות. הערה: ניתן להשתמש במבני הנתונים שנלמדו בכיתה כקופסאות שחורות, מבלי לממשן. פתרונות נבחרים שאלה 1:

4 נכתוב פונקציה לא רקורסיבית שמדפיסה את כל הנתונים המאוכסנים בעץ בינארי T ב-.Postorder נניח שנתון אובייקט T מסוג Tree שבנוי מקדקודים מסוג,Node ומוגדרות הפעולות הבאות: IsEmpty() - פעולה שמחזירה 1 אם העץ ריק, 0 אחרת. T. בעץ n פעולה שמחזירה את הילד השמאלי של קדקוד - LeftChild(Node (n T. בעץ n פעולה שמחזירה את הילד הימני של קדקוד RightChild(Node (n T. בעץ n פעולה שמחזירה את הנתונים המאוכסנים בקדקוד - Retrieve(Node (n T. פעולה המחזירה את הקדקוד שהוא שורש העץ - Root() נשתמש במחסנית כבמבנה נתונים נוסף. במחסנית נשמור רשומות שיכילו את שם הקדקוד שבו ביקרנו, ושדה visited שיספור בכמה מילדיו כבר ביקרנו. כך רשומה במחסנית תוגדר להיות: struct SType{ Node node; // a node in the tree. int visited; // number of children of node that were visited. ; על המחסנית מסוג Stack מוגדרות הפעולות הרגילות של מחסניות. בנוסף אנו מגדירים פונקציה (v Create_and_Push(Node,n int אשר יוצרת רשומה מסוג SType שבה הקדקוד הוא n וערך השדה Pop() הפעולה S. הרגילה את הרשומה הזאת למחסנית Push ודוחפת בעזרת פעולת ה- v, הוא visited מחזירה רשומה מסוג.Stype void NPostOrder(Tree T) { SType current; // current node in tree, and number of children visited. Stack S; // Stack of items of type SType. if (!T.IsEmpty()) { S.MakeEmpty(); S.Create_And_Push(T.root(), 0); while (!S.IsEmpty(){ current = S.Pop(); if (current.visited == 0){ // visit left child of current. S.Create_And_Push(current.node, 1); if (T.LeftChild(current.node)!= NULL) S.Create_And_Push(T.Leftchild(current.node), 0); else if (current.visited == 1){ else // visit right child of current. S. S.Create_And_Push(current.node, 2); if (T.RightChild(current.node)!= NULL) S.Create_And_Push(T.Rightchild(current.node), 0); // both children visited print current. cout << T.Retrieve(current.node); שאלה 2: תאור עילי של האלגוריתם: 1. נעבור על העץ רמה-רמה. 2. בתחילת כל איטרציה יהיו ב- Q1 כל האיברים של הרמה הנוכחית שהמסלול אליהם מהשורש מכיל רק נתונים זוגיים. Q2 יהיה ריק.

5 נשתמש עתה ב- Q1 כדי לשים ב- Q2 את כל האיברים של הרמה הבאה שהמסלול אליהם מהשורש מכיל רק נתונים זוגיים. תוך כדי כך נרוקן את Q1. נחליף את תפקידיהם של Q1 ו- Q הערות: I) השימוש בשני תורים מאפשר לנו לדעת מתי נגמרת רמה. (II בתורים נשמור את הכתובות לצמתים, בכדי שנוכל להמשיך ולגשת לילדים שלהם. LongestEvenPath(Tree T) { Q1.MakeEmpty() Q2.MakeEmpty() Len = 0 if ( T.data is even ) Q1.EnQueue(T) while (!Q1.IsEmpty( ) ){ while (!Q1.IsEmpty ( ) ){ temp = Q1.DeQueue() if ( temp.left exists and temp.left.data is even ) Q2.EnQueue(temp.left) if ( temp.right exists and temp.right.data is even ) Q2.EnQueue(temp.right) Len++ Change roles of Q1 and Q2 return Len תאור מפורט של האלגוריתם:

6 class TNode{ private: ; public: Type data; TNode * left, * right; int IsRight, IsLeft; TNode(Type x); ~TNode();. שאלה 3: א. הנה ההגדרה ב- ++C של קדקוד בעץ חיפוש מחויט: class Threaded{ private: ; public: TNode * root; Threaded(); ~Threaded(); void Insert(Type x);. TNode::TNode(Type x) { data = x; IsRight = IsLeft = 0; left = right = NULL; וההגדרה עבור העץ תהיה: ה- constructor של הקדקוד יהיה: ב. הפונקציה Insert דומה לפונקציה Insert בעץ חיפוש רגיל, רק שעלינו לעדכן גם את השדות left, right ואת השדות IsRight, IsLeft של הקדקוד החדש ושל ההורה שלו. void Threaded::Insert(Type x) { TNode * newnode = new TNode(x); TNode * temp = root; TNode * parent = NULL; // new allocated node. // current node in tree. // parent of temp. while (temp!= NULL){ // find parent of newnode. parent = temp; if (temp->data > x) { if (temp->isleft == 1) temp = temp->left; else temp = NULL; else { if (temp->isright == 1) temp = temp->right; else temp = NULL; If (parent == NULL) // insert newnode as root. root = newnode;

7 else if (parent->data > x){ // insert newnode as left child of parent newnode->right = parent; // parent is successor of newnode newnode->left = parent->left; // left child of parent is predecessor of newnode parent->left = newnode; parent->isleft = 1; else{ // insert newnode as right child of parent newnode->right = parent->right; newnode->left = parent; parent->right = newnode; parent->isright = 1; ג. הפונקציה Inorder שעוברת על העץ בצורה לא רקורסיבית תיעזר כמובן במצביעים.left,right void Threaded::Inorder(void) { TNode * temp = root; // current position in tree. if (temp!= NULL){ while (temp->isleft == 1) // start visiting from leftmost node in tree. temp = temp ->left; while (temp!= NULL){ cout << temp->data >> ; // visit node if (temp->isright == 0) // node has no right child go to its successor temp = temp->right; else{ // node has a right child - successor is // leftmost node in right subtree temp = temp->right; while (temp->isleft == 1) temp = temp ->left; את שאלה 4: א. נסמן ב- N את מספר הצמתים הכללי בעץ, ב- Nleaves את מספר העלים בעץ, וב- N 2deg מספר הקודקודים מדרגה 2 (בעלי שני ילדים).. Nleaves = N 2deg+ נוכיח באינדוקציה על N ש, - 1 בסיס האינדוקציה:,N=1 בעץ יש קדקוד בודד. = 0 deg, Nleaves = 1, N 2 ואכן. Nleaves = N 2deg+ 1 הנחת האינדוקציה: נניח שלעץ ' T עם N-1 צמתים מתקיים, + 1 ') T Nleaves( T ') = N 2deg( שלב המעבר: נוכיח שגם לעץ T עם N צמתים מתקיים, + 1 ) T. Nleaves( T ) = N 2deg( בהינתן עץ T עם N צמתים, כידוע בכל עץ יש עלה נסמן:ב- x עלה בעץ T, ב- y את ההורה של x, וב- ' T, את העץ המתקבל מ- T אחרי הסרת x מהעץ. ב- ' T יש N-1 צמתים, ולכן עפ"י הנחת האינדוקציה + 1 ') T. Nleaves( T ') = N2deg( נפצל לשני מקרים: I) ב- x T היה בן יחיד של (y y היה ב- T מדרגה 1):

8 במקרה זה מספר העלים ב- ' T הוא כמספר העלים ב- T (הסרת x הפכה את y להיות עלה). כמו כן מספר הצמתים מדרגה 2 נשאר אף הוא ללא שינוי, כלומר:. Nleaves( T ') = Nleaves( T ), N 2deg( T ') = N 2deg( T ) והיות ש- + 1 ') T, Nleaves( T ') = N 2deg( גם + 1 ) T. Nleaves( T ) = N 2deg( (II ב- x T היה בן שני של (y y היה ב- T מדרגה 2): במקרה זה מספר העלים ב- ' T קטן ב- 1 ממספר העלים ב- T (הסרת x לא הפכה את y להיות עלה). וכן מספר הצמתים מדרגה 2 אף הוא קטן ב- 1 (לפני הסרת y x היה מדרגה 2, ואחרי ההסרה לא), כלומר:. Nleaves( T ') = Nleaves( T ) 1, N 2deg( T ') = N 2deg( T ) 1 והיות ש- + 1 ') T, Nleaves( T ') = N 2deg( אזי. Nleaves( T ) = N2deg( T ) כלומר + 1, Nleaves( T ) 1 = N 2deg( T ) 1+ 1 ב. נוכיח באינדוקציה על גובה העץ h ש, בעץ בינארי שלם מגובה h יש 1+h 1 2 קדקודים. בסיס האינדוקציה: 0=h, כלומר בעץ יש קדקוד בודד. ואכן, = נניח שהטענה נכונה עבור עצים מגובה h, ונוכיח לעצים מגובה 1+h. עץ שלם מגובה 1+h בנוי משורש שאליו מחוברים שני עצים שלמים מגובה h כל אחד. לפי הנחת האינדוקציה בעץ שלם מגובה h יש 1+h 1 n = 2 קדקודים. לכן, סה"כ מספר הקדקודים בעץ השלם מגובה h+1 הוא: h+2 1.(2 h+1 1)+ (2 h+1 1) + 1 = 2 ג. מספר העלים בעץ בינארי שלם בעל n קדקודים הוא 2/(1+n). נוכיח תחילה באינדוקציה על גובה העץ h, שבעץ בינארי שלם מגובה h, יש 2 h עלים. בסיס האינדוקציה: 0=h, בעץ יש קדקוד בודד ואכן = נניח שהטענה נכונה לעצים מגובה h, ונוכיח לעצים מגובה 1+h. בעץ בינארי שלם מגובה h יש לפי הנחת האינדוקציה 2 h עלים. עץ שלם מגובה 1+h יתקבל ממנו ע"י הוספת רמה שלמה של עלים. אנחנו מוסיפים שני עלים על כל עלה שהיה קיים והפך לקדקוד פנימי. לכן בסה"כ מספר העלים בעץ מגובה 1+h יהיה 1+h 2 2 h = 2 כנדרש. כעת, לפי סעיף ב' בעץ מלא מגובה יש 1+h 1 2=n קדקודים סה"כ, והראינו כעת שמתוכם יש 2 h עלים. ולכן מספר העלים כפונקציה של n הוא: 2/(1+n). שאלה 5: האלגוריתם למציאת העוקב Successor של מספר x בעץ חיפוש יהיה: אם ל- x יש ילד ימני אז העוקב של x הוא המינימום בתת-עץ ימין של x. אחרת העוקב של x הוא ההורה הקדמון הכי נמוך של x שילדו השמאלי גם הוא הורה-קדמון של x. כדי למצוא את העוקב הזה y נלך מ- x למעלה עד שנמצא קדקוד שהוא ילד שמאלי של ההורה שלו. העוקב של x יהיה ההורה של הקדקוד הזה. (הערה: ייתכן בהחלט שהעוקב הוא ההורה הישיר של x. במקרה זה הוא יימצא מייד בתחילת לולאת ה-.(while Successor(Node x) { if (RightChild(x)!= NULL) return Min(RightChild(x)); y = Parent(x); while ((y!= NULL) && (x == RightChild(y)){ x = y; y = Parent(y); return y;

9 הפונקציה (n Min(Node מחזירה את המינימום בתת-עץ שהשורש שלו הוא n. יעילות האלגוריתם היא Θ(h) כאשר h גובה העץ. שאלה 6: א. הטענה נכונה. אפשר להוכיח זאת באינדוקציה על מספר האיברים בעץ, כאשר את הנחת האינדוקציה מפעילים על שני תתי העצים של השורש. ב. הטענה אינה נכונה. דוגמה נגדית: ג. הטענה אינה נכונה. דוגמה נגדית: T 3 3 T שאלה 7: א) הנה העץ המתקבל לאחר הוספת והנה העץ המתקבל לאחר הורדת 3.

10 שאלה 7, סעיף ב( i ) פתרון 1: מתבסס על כך שאם סורקים עץ בינארי בסדר inorder מקבלים סדרה ממוינת (עולה) אם ורק אם העץ הוא עץ חיפוש. הנה תיאור מפורט של האלגוריתם (כולל פונקצית עזר): אלגוריתם IsSearchTree מקבל עץ, מחזיר ערך אמת true) או (false אתחל מערך A של מספרים שגודלו כמספר הצמתים בעץ אתחל ערך index ל 0 קרא ל InorderToA עם השורש כפרמטר לכל index מ 0 עד 2-n אם A[index+1] A[index] > החזר false החזר true אלגוריתם InorderToA מקבל מצביע לצומת node אם node אינו NULL קרא ל InorderToA רקורסיבית עם תת העץ השמאלי של node כפרמטר תן ל A[index] את הערך שבצומת node הגדל את index ב 1 קרא ל InorderToA רקורסיבית עם תת העץ הימני של node כפרמטר, וכך גם המעבר על המערך). יעילות: Θ(n) (סריקה ב inorder לוקחת זמן Θ(n) הערות: את מספר הצמתים בעץ ניתן לחשב בעזרת אלגוריתם שגם הוא סורק את העץ בסדר inorder ובכל ביקור בצומת מגדיל מונה ב 1. היעילות לא תשתנה. במקום מערך ניתן להשתמש בתור, או מחסנית (במקרה של מחסנית יש להפוך את כוון ההשוואות). למעשה מספיק משתנה עזר בודד שישמור את הערך של הצומת האחרון שבקרנו בו, אם נבצע את ההשוואות תוך כדי הסריקה ב. inorder פתרון 2: סריקת העץ תוך בדיקה בכל צומת שתוכן הצומת גדול מהערך המקסימלי בתת העץ השמאלי וקטן מהערך המינימלי בתת העץ הימני. (לא מספיק להשוות לבן השמאלי והימני!). תיאור מפורט של האלגוריתם (כולל פונקצית עזר): אלגוריתם IsSearchTree מקבל עץ, מחזיר ערך אמת true) או (false אם העץ ריק החזר true אחרת קרא ל IsSearchTree1 עם השורש והחזר את הערך המוחזר מהקריאה (אין חשיבות לערכים שיוחזרו דרך שני הפרמטרים הנוספים)

11 אלגוריתם IsSearchTree1 מקבל מצביע לצומת node מחזיר ערך אמת true) או (false וכאשר מוחזר true יוחזרו בנוסף שני ערכים min ו max (למשל בעזרת פרמטרים ref נוספים) אם ל node אין ילדים החזר את הערך, true וב max וב min את הערך שבצומת (כלומר ( node->data אם ל node יש בן שמאלי קרא רקורסיבית ל IsSearchTree1 על הבן השמאלי של node אם הוחזר false החזר false אחרת (הוחזר true וכן ערך של lmin ושל ( lmax אם הערך שבצומת קטן מ lmax החזר false אחרת min מקבל את הערך של lmin אחרת (ל node אין בן שמאלי) min מקבל את הערך שבצומת אם ל node יש בן ימני קרא רקורסיבית ל IsSearchTree1 על הבן הימני של node אם הוחזר false החזר false אחרת (הוחזר true וכן ערך של rmin ושל ( rmax אם הערך שבצומת גדול מ rmin החזר false אחרת max מקבל את הערך של rmax אחרת (ל node אין בן ימני) max מקבל את הערך שבצומת החזר true ועת הערכים max ו min שחושבו יעילות: Θ(n) (האלגוריתם מבקר בכל צומת, ומבצע בה מספר קבוע של פעולות). שאלה 7, סעיף ב( ii ) פתרון 1: שיעילותו אינה הטובה ביותר, משתמש בפונקצית עזר לחישוב גובה של עץ: אלגוריתם IsAvlTree מקבל עץ, מחזיר ערך אמת true) או (false אם T הוא עץ חיפוש בינרי (בדיקה ע"י האלגוריתם מסעיף א') קרא ל IsAvlTree1 עם השורש והחזר את הערך המוחזר מהקריאה אחרת החזר false אלגוריתם IsAvlTree1 מקבל מצביע לצומת,node מחזיר ערך אמת true) או (false אם node הוא העץ הריק (Null) החזר true אם קריאה רקורסיבית של IsAvlTree1 על תת עץ שמאל של node מחזירה true וגם קריאה רקורסיבית של IsAvlTree1 על תת עץ ימין של node מחזירה true וגם הערך המוחלט של הפרש גבהי תתי העצים קטן מ 2 כלומר < 2 node->right) height( node->left)-height( החזר true אחרת (לפחות אחד מ 3 התנאים הללו הוא ( false החזר false אלגוריתם height מחזיר מספר שלם: אם T הוא העץ הריק (Null) החזר ערך 1-

12 אחרת החזר 1 ועוד המקסימום מבין T->left) height( ו T->right) height( יעילות: בגלל הקריאות לחישוב הגובה מתקבלת נוסחת הנסיגה: T(n) = T(m) + T(n-m-1) + Θ(m) + Θ(n-m+1) = T(m) + T(n-m-1) + Θ(n) כש m הוא מס' הצמתים בתת העץ השמאלי => m => n 0 (חישוב גובה עבור עץ בעל p צמתים לוקח זמן Θ(p), כי מבקרים בכל צומת ומבצעים בה מספר קבוע של פעולות). ולכן מתקבל הזמן (n Θ(n log במקרה הטוב ועבור עץ אקראי, ) 2 Θ(n במקרה הגרוע. פתרון 2: יותר יעיל (למעשה זהו מימוש יותר יעיל של אותו האלגוריתם, על ידי האחדת החישוב של.(height עם IsAvlTree אלגוריתם IsAvlTree מקבל עץ, מחזיר ערך אמת true) או (false אם T הוא העץ הריק (Null) החזר true אם T הוא עץ חיפוש בינרי (בדיקה ע"י האלגוריתם מסעיף א') קרא ל IsAvlTree1 עם השורש והחזר את הערך המוחזר מהקריאה (אין חשיבות לערך שיוחזר דרך הפרמטר הנוסף) אחרת החזר false אלגוריתם IsAvlTree1 מקבל מצביע (לא (NULL לצומת node מחזיר ערך אמת true) או (false וכאשר מוחזר true יוחזר בנוסף ערך height (למשל בעזרת פרמטר ref נוסף) אם ל node אין ילדים החזר את הערך, true וב height החזר 0 אם ל node יש בן שמאלי קרא רקורסיבית ל IsAvlTree1 על הבן השמאלי של node אם הוחזר false החזר false אחרת (הוחזר true וכן ערך של ( lheight אחרת (ל node אין בן שמאלי) lheight מקבל את הערך 0 אם ל node יש בן ימני קרא רקורסיבית ל IsAvlTree1 על הבן הימני של node אם הוחזר false החזר false אחרת (הוחזר true וכן ערך של ( rheight אחרת (ל node אין בן ימני) rheight מקבל את הערך 0 תן ל height את הערך 1 ועוד המקסימום של lheight ו rheight החזר true יעילות: האלגוריתם מבקר בכל צומת, ומבצע בה מספר קבוע של פעולות ולכן זמן הריצה הוא Θ(n). דרך אחרת לחישוב זמן הריצה היא לחשב את נוסחת הנסיגה: T(n) = T(m) + T(n-m-1) + Θ(1) כש m הוא מס' הצמתים בתת העץ השמאלי => m => n 0 ואכן מתקבל הזמן Θ(n) במקרה הגרוע (פתרון נוסחת הנסיגה בלתי תלוי בערך של m בכך שלב). הערות: ניתן לכתוב וריאציה על IsAvlTree1 שתחזיר את גובה העץ אם הוא עץ AVL ו 1- אם לא. במקרה זה אין צורך בפרמטר העזר.

13 שאלה 8: x את ה- ADT הנ"ל נשמור בעץ 2-3 שממוין עפ"י היחס ) ( של הנקודות הנשמרות במבנה, כל אחד מנתוניו y x יהיה מצביע לעץ 2-3 נוסף המכיל את הנקודות בעלי אותו יחס. עץ זה יהיה ממוין עפ"י קואורדינטת ה- x y של הנקודה, והנתונים בו יהיו הנקודות עצמן (נשים לב שלא יתכנו שתי נקודות בעלות אותו יחס, ואותה קואורדינטת x). לצורך מימוש ה- ADT נשתמש אם כן בשני סוגים של עצי 2-3: PointsTree העץ שיכיל את כל הנקודות בעלות אותו היחס. ממוין עפ"י: יחס הסדר של מספרים ממשיים. טיפוס הנתונים: נקודות מהצורה (y,x). FactorsTree העץ שיכיל את המצביעים לעצים בעלי אותו יחס. ממוין עפ"י: יחס הסדר של מספרים ממשיים. טיפוס הנתונים: מצביע לעץ.PointsTree המחלקה שתממש את ה- ADT תכיל מצביע מהצורה:.FactorsTree* root להלן המימוש של הפעולות הנדרשות: Insert(x, y){ PointsTree* PointsT; PointsT = root->find( x y ); if (PointsT == NULL){ PointsT = new PointsTree; PointsT->Insert ( x, (x,y) ); root->insert( x, PointsT ); y else PointsT->Insert ( x, (x,y) ); ניתוח יעילות: נשים לב שבעץ root יש לכל היותר n נתונים (עצים עם נקודות בעלי אותו יחס), היות שלא ייתכנו יותר מ- n יחסים שונים. כמו כן בכל PointsTree לא יהיו יותר מ- n נקודות, היות שסה"כ יש n נקודות. ולכן ה- Find ייקח ((n,o(log( וגם כל אחת מההכנסות (לשני סוגי העצים) תיקח ((n,o(log( וסה"כ יפעל האלגוריתם ב- ((n.o(log( Point* Delete(x, y){ PointsTree* PointsT; Point* P=NULL; PointsT = root->find( x y ); if (PointsT!= NULL){ P = PointsT->Delete( x ); if (PointsT->IsEmpty( ) ) root->delete( x y ); return P; ניתוח יעילות:

14 מאותם שיקולים, ה- Find ייקח ((n,o(log( וגם ה- Delete ייקח ((n,o(log( וסה"כ יפעל האלגוריתם ב-.O(log( n)) SameFactor(x, y){ PointsTree* PointsT;. Θ( k) PointsT = root->find( x y ); if (PointsT!= NULL) PointsT->Print( ); ניתוח יעילות: מאותם שיקולים, ה- Find ייקח ולכן סה"כ: n)). Ok ( + log( ((n,o(log( ואם בעץ הנקודות יש k נקודות אז ה- Print ייקח